Probabilistic Method for Performing Memory Prefetching

ABSTRACT

A method for preforming memory prefetching is disclosed. A stream length histogram (SLH) is initially generated based on a stream of Read and Write requests intended for a system memory. A determination is then made whether or not to issue a prefetch command after a Read request based on information within the generated SLH. In a determination that a prefetch command should be issued, prefetch command to be sent to the system memory is issued along with other commands.

CROSS REFERENCE TO RELATED APPLICATIONS

The present application is related to Ser. No. 11/______ , entitled “PRIORITY-BASED MEMORY PREFETCHER,” filed on even date (IBM docket number AUS920070272US1), which is assigned to the assignee of the present application.

BACKGROUND OF THE INVENTION

1. Technical Field

The present invention relates to prefetching in general, and more particularly, to a method for performing prefetching. Still more particularly, the present invention relates to a method for performing memory prefetching using an adaptive stream detection scheme.

2. Description of Related Art

Early prefetching techniques mainly focused on exploiting streaming workloads. While regular forms of spatial locality are relatively easy to predict, traditionally it has been difficult to exploit irregular patterns of spatial locality and it is even more difficult to exploit low amounts of spatial locality.

Recently, a class of aggressive prefetching techniques has arisen from the notion of Spatial Locality Detections. Those techniques track accesses to regions of memory so that spatially correlated data can be prefetched together. The main advantage of those techniques is their ability to exploit irregular forms of spatial locality. However, the main disadvantage is their reliance on massive tables that tends to occupy large chip area and consumes a lot of power.

Consequently, it would be desirable to provide an improved method for performing prefetching.

SUMMARY OF THE INVENTION

In accordance with a preferred embodiment of the present invention, a stream length histogram (SLH) is initially generated based on a stream of Read and Write requests intended for a system memory. A determination is then made whether or not to issue a prefetch command after a Read request based on information within the generated SLH. In a determination that a prefetch command should be issued, prefetch command to be sent to the system memory is issued along with other commands.

All features and advantages of the present invention will become apparent in the following detailed written description.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention itself, as well as a preferred mode of use, further objects, and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, wherein:

FIG. 1 is an example of a stream length histogram for one epoch of the GemsFDTD benchmark from the SPEC2006 suite; and

FIG. 2 is a block diagram of a memory controller having a prefetcher in which a preferred embodiment of the present invention is incorporated.

DETAILED DESCRIPTION OF A PREFERRED EMBODIMENT

In accordance with a preferred embodiment of the present invention, a new technique is utilized to augment the effectiveness of a stream prefetcher. Such technique is based on two observations. First, memory intensive workloads with low amounts of spatial locality are likely to still contain many very short “streams” (as short as two consecutive cache lines). Second, a stream prefetcher can effectively prefetch those short streams if it only knows when to be aggressive.

To understand the second observation, recall that a stream prefetcher looks for accesses to k consecutive cache lines, at which point a k+1^(st) cache line is prefetched, and prefetching continues until a useless prefetch is detected. Thus, the value of k determines the stream prefetcher's aggressiveness, and such value is typically fixed at design time. Even with a small value of k, a stream prefetcher does not fare well on short streams because the stopping criterion is a useless prefetch. For example, on a workload in which every stream is of length 2, a k=1 policy can successfully prefetch a second cache line of each stream, but each successful prefetch will be followed by a useless prefetch, so 50% of its prefetches is useless.

The present invention uses an Adaptive Stream Detection scheme to guide the aggressiveness of a prefetch policy that is based on the workload's observed amount of spatial locality, as measured by a stream length histogram (SLH). An SLH is a dynamically computed histogram that attributes each memory access to a particular stream length. For example, if an SLH indicates that 70% of memory requests are parts of streams of length 2 and that 30% of the memory requests are parts of streams of length 1, then an effective strategy will always prefetch a second cache line of a stream but never a third line. Thus, the Adaptive Stream Detection scheme can predict when to stop prefetching without incurring a useless prefetch.

With reference now to the drawings, and in particular to FIG. 1, there is depicted an example of an SLH for one epoch of the GemsFDTD benchmark from the SPEC2006 suite. As shown, the height of a bar at location m represents the number of Read commands that are part of a stream of length m. Depending on the detected stream length of the current Read request, a prefetcher checks the SLH and determines how many, if any, sequential cache lines needs to be prefetched.

In the example SLH of FIG. 1, 21.8% of all Read requests are part of streams of length 1, 43.7% of the Reads are part of streams of length 2, etc. The rightmost bar indicates that 1.2% of all Read requests are part of streams of length 16 or more. Given this information, when a Read request arrives and is the first element of a new stream, a prefetch request should be issued because it is more likely to be part of a stream of length 2 or longer (78.2% probability) than to be part of a stream of length 1 (21.8% probability). On the other hand, if a Read request is a second line of a stream, a prefetch should not be issued because there is a 43.7% probability that it is part of a stream of length 2, which is greater than the (100%−21.8%−43.7%=) 34.5% likelihood that it is part of a longer stream. With similar reasoning, prefetches should be not issued for any Read request whose current stream length is 3 or greater than 6. This example shows that the use of an SLH allows a prefetcher to make rather sophisticated prefetching decisions based on the length of an individual stream.

A prefetcher can also use an SLH to decide whether to generate multiple prefetches. For example, when R_(n) is part of a stream of length 1A, a prefetcher decides whether to generate two consecutive prefetches by adding the probabilities of the first two bars and comparing the sum with the rest of the histogram. If the sum of the first two bars is less than the sum of the other bars, and if the prefetcher has already decided to prefetch one line, it generates a prefetch for the second line as well.

Because memory access behavior typically varies over time, an SLH is constructed periodically after every e Read requests, where e is known as an epoch. Thus, in every epoch, a new SLH is constructed for use in the next epoch.

Two functions, lht( ) and P( ), can be defined to be used to compute an SLH, as follows:

-   lht(i): the number of Read requests that are part of streams of     length i or longer, where 1≦i≦fs, and fs is the longest stream to be     tracked. For any i>fs, lht(i)=0. -   P(i,j): the sum of probabilities that a Read request is part of any     stream of length k, where i≦k≦j and 1≦i,j≦fs. P(i,j) can be defined     in terms of lht( ) as follows:

P(i,j)=[lht(i)−lht(j+1)]/lht(1)  (1)

The value of the i^(th) bar of an SLH equals P(i,i).

In order to decide whether or not to issue a prefetch, the following condition is checked to determine if it is satisfied for a Read request, R_(n), that is the i^(th) element of a stream:

P(i,i)<P(i+1,fs)  (2)

This inequality states that the probability that the most recent Read request, R_(n), is part of a stream of length i is smaller than it being a part of a stream of length longer than i. Inequality (2) can be simplified as follows:

$\begin{matrix} {{P\left( {i,i} \right)} < {P\left( {{i + 1},{f\; s}} \right)} \equiv \frac{{l\; h\; {t(i)}} - {l\; h\; {t\left( {i + 1} \right)}}}{l\; h\; {t(1)}}} & {(3)} \\ {< \frac{{l\; h\; {t\left( {i + 1} \right)}} - {l\; h\; {t\left( {{f\; s} + 1} \right)}}}{l\; h\; {t(1)}}} & {(4)} \\ {\equiv {l\; h\; {t(i)}} < {2 \times l\; h\; {t\left( {i + 1} \right)}}} & {{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}(5)} \end{matrix}$

Basically, inequality (5) can be utilized to make a next line prefetch decision. A generalized version of inequality (5) to prefetch k consecutive lines after a Read request R_(n) can be as follows:

lht(i)<2×lht(i+k)  (6)

The Adaptive Stream Detection scheme, which uses SLH to capture spatial locality and guide prefetch decisions, can be implemented in a memory controller having a prefetcher. With reference now to FIG. 2, there is illustrated a block diagram of a memory controller having a prefetcher in which a preferred embodiment of the present invention is incorporated. As shown, a memory controller 20 includes a scheduler 21, a centralized arbiter queue (CAQ) 22 and multiple read/write reorder queues 23. Memory controller 20 is preferably located between cache memories and a system memory 24. Memory commands from the processor entering memory controller 20 are initially placed in reorder queues 23. On each cycle, scheduler 21 selects a command from reorder queues 23 and then sends the selected command to CAQ 22. In turn, CAQ 22 transmits commands to system memory 24 in a first-in-first-out manner.

Read commands entering memory controller 20 are sent to reorder queues 23 and to a stream filter 25. Stream filter 25 keeps track of Read streams and generates an SLH accordingly. The Read streams information from stream filter 25 is then fed to a prefetch generator 26 that decides whether a prefetch command should be issued. If a prefetch command should be fetched, a prefetch command is placed in a low priority queue (LPQ) 27 where a final scheduler 28 can consider the prefetch command along with other commands in LPQ 27 and CAQ 22 during the selection of commands to issue to system memory 24. Any prefetched data are then stored in a prefetch buffer 29.

Prefetch buffer 29 is first checked before Read commands are placed in CAQ 22 so that Read commands can be satisfied by Prefetch buffer 29, in which case the latency of going to system memory 24 is saved and Read commands are squashed. Prefetch buffer 29 is checked again when final scheduler 28 selects a Read command from CAQ 22 to send to system memory 24. The second check is useful because the desired data may have arrived in prefetch buffer 29 while the Read command is resided in CAQ 22.

In order to maintain Read streams information, stream filter 25 uses one slot to track each Read stream. Each slot maintains the last address accessed by a Read stream, the length of the Read stream, the direction of the Read stream, and the lifetime of the Read stream (indicating when the Read stream should be evicted). These slots are used as follows.

If a Read request R_(n) is not part of a Read stream and if there is a vacant slot in stream filter 25, the last access field is set to the address of the Read request, the length field is initialized to 1, the lifetime is initialized to a predetermined value, and the direction is set to Positive.

If a Read request R_(n) is not part of a Read stream and there is no available slot, no prefetch will be generated after Read request R_(n), but the SLH structure is updated as if a Read stream of length 1 had been detected.

If a Read request R_(n) is the most recent element of a previously detected Read stream, the stream length is incremented by 1, the last access is set to the address of Read request R_(n), and the lifetime of the stream is incremented by a predetermined value.

The direction of the Read stream is set to negative if the length of the previous stream is 1 and the address of Read request R_(n) is smaller than the last address of the Read stream. At every processor cycle, the lifetime fields are decremented by one. A Read stream is evicted from a slot when its lifetime expires. At this point, the SLH structure is updated using the length value in stream filter 25. At the end of each epoch, all Read streams are evicted from stream filter 25.

Prefetch buffer 29 holds data that are fetched from system memory 24 by the memory-side prefetcher. Prefetch buffer 29 is assumed to be a set associative cache having an least-recently used replacement policy. When there is a Write request to an address in prefetch buffer 29, the entry in prefetch buffer 29 is invalidated. The entry is also invalidated if a regular Read request matches the address, because in such cases the data will likely be moved to the L1 or L2 cache, so it is unlikely to be useful in prefetch buffer 29 again.

For simplicity, the explanation on the SLH implementation is limited to streams with increasing addresses only, and to prefetching one cache line only. However, it is straightforward to generalize this approach to streams with decreasing addresses and multiple line prefetching.

Rather than implementing the SLH explicitly, the information in the SLH is constructed using two Likelihood Tables LHT_(curr) and LHT_(next). Both LHT_(curr) and LHT_(next) are of length fs and correspond to the lht( ) function discussed previously. A given epoch uses and updates information from LHT_(curr) and gathers information for the start of the next epoch in LHT_(next). LHT_(next) is updated using the information from stream filter 25. When an entry of length k in stream filter 25 is invalidated, LHT_(next)[i] is incremented by k, for all i, where 1≦i≦k. At the end of an epoch, LHT_(next) is modified using the remaining valid entries in stream filter 25; the contents of LHT_(next) are moved to LHT_(curr); and LHT_(next) is re-initialized. Each entry of LHT_(curr) and LHT_(next) is a log₂(m) bit counter, where m is the maximum epoch length.

LHT_(curr) is used to make prefetch decisions for the current epoch. LHT_(curr) table has one comparator for each pair of consecutive table entries, i.e., LHT_(curr)[i] and LHT_(curr)[i+1], for 1≦i≦fs. At the beginning of an epoch, the contents of LHT_(curr) are used to construct an SLH. As the epoch progresses, this information is modified using the observed stream lengths of the current epoch. When an entry of length k in stream filter 25 is invalidated, the value of LHT_(curr)[i] is decremented by k, for all i, where 1≦i≦k.

When stream filter 25 observes that a Read request is part of a stream of length k, prefetch requests are generated using the output of the comparison of LHT_(curr)[k] and LHT_(curr)[k+1], as in inequality (5). Instead of multiplying LHT_(curr)[k+1] by 2, for any k, the comparator for the (LHT_(curr)[k], LHT_(curr)[k+1]) pair takes the left shifted value of LHT_(curr)[k+1] as input.

As has been described, the present invention provides a method for performing memory prefetching using an Adaptive Stream Detection scheme. The method of the present invention has two benefits. It extends the notion of a stream to include streams as short as two cache lines. Thus, while it is inherently a stream-based approach, it provides benefits for workloads, such as commercial applications, that are not traditionally viewed as stream-based. Because it is stream-based, it has low hardware costs, using small tables that have low static power leakage.

While an illustrative embodiment of the present invention has been described in the context of a fully functional memory controller, those skilled in the art will appreciate that the software aspects of an illustrative embodiment of the present invention are capable of being distributed as a program product in a variety of forms, and that an illustrative embodiment of the present invention applies equally regardless of the particular type of media used to actually carry out the distribution. Examples of the types of media include recordable type media such as thumb drives, floppy disks, hard drives, CD ROMs, DVDs, and transmission type media such as digital and analog communication links.

While the invention has been particularly shown and described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention. 

1. A method for preforming memory prefetching, said method comprising: generating a stream length histogram (SLH) based on a stream of Read and Write requests intended for a system memory; determining whether or not to issue a prefetch command after a Read request based on information within said generated SLH; and in a determination that a prefetch command should be issued, issuing a prefetch command to be sent to said system memory along with other commands.
 2. The method of claim 1, wherein a prefetch command for prefetching k consecutive lines after a Read request is issued when the following equality is met: lht(i)<2×lht(i+k) where lht(i) is the number of Read requests that are part of said stream of length i or longer, where 1≦i≦fs, and fs is the longest stream to be tracked.
 3. The method of claim 2, wherein method further includes constructing said SLH using length Fs likelihood tables LHT_(curr) and LHT_(next) that correspond to said lht( ) function.
 4. A computer storage medium having a computer program product for preforming memory prefetching, said computer readable medium comprising: computer program code for generating a stream length histogram (SLH) based on a stream of Read and Write requests intended for a system memory; computer program code for determining whether or not to issue a prefetch command after a Read request based on information within said generated SLH; and computer program code for, in a determination that a prefetch command should be issued, issuing a prefetch command to be sent to said system memory along with other commands.
 5. The computer storage medium of claim 4, wherein a prefetch command for prefetching k consecutive lines after a Read request is issued when the following equality is met: lht(i)<2×lht(i+k) where lht(i) is the number of Read requests that are part of said stream of length i or longer, where 1≦i≦fs, and fs is the longest stream to be tracked.
 6. The computer storage medium of claim 5, wherein computer storage medium further includes computer program code for constructing said SLH using length Fs likelihood tables LHT_(curr) and LHT_(next) that correspond to said lht( ) function.
 7. A memory controller comprising: a stream filter for generating a stream length histogram (SLH) based on a stream of Read and Write requests intended for a system memory; and a prefetch generator for determining whether or not to issue a prefetch command after a Read request based on information within said generated SLH, and for issuing a prefetch command to be sent to said system memory along with other commands in a determination that a prefetch command should be issued.
 8. The memory controller of claim 7, wherein a prefetch command for prefetching k consecutive lines after a Read request is issued when the following equality is met: lht(i)<2×lht(i+k) where lht(i) is the number of Read requests that are part of said stream of length i or longer, where 1≦i≦fs, and fs is the longest stream to be tracked.
 9. The memory controller of claim 8, wherein memory controller further includes two length Fs likelihood tables LHT_(curr) and LHT_(next) that correspond to said lht( ) function for representing said SLH. 